/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package Delta;

import Jama.Matrix;

/**
 *
 * @author Ahmet
 */
public class Reken {
    
    public static double makeMutl(double Mult, double El, double Et)
    {
        return ((double) ((Mult / El) * Et));
    }
    
    //Stap 2a: lamel aanmaken vanuit vezel (fiber) en matrix (epoxy)
    /**
     * Maakt een {@code Lamel} aan de hand van een {@code Fiber}, {@code Epoxy} en volumefractie.
     * @param f De fiber (vezel) waaruit de {@code Lamel} zal gaan bestaan.
     * @param e De epoxy (matrix/lijm) waaruit de {@code Lamel} zal gaan bestaan.
     * @param vf Volumefractie
     * 
     * @return de {@code Lamel} die is aangemaakt
     */
    public static Lamel tclaml(Fiber f, Epoxy e, double vf) {
        double Ef = f.getE();
        double rhof = f.getRho();
        double Muf = f.getMu();
        double afl = f.getAl();
        double afr = f.getAr();
        //double vf = f.vf;
        double Em = e.getE();
        double rhom = e.getRho();
        double Mum = e.getMu();
        double am = e.getA();
        double vm = (double) (1 - vf);
        //Parameters berekenen
        //Parameters Gf en Gm (glijdingsmodulus, fibre en matrix) bepalen:
        //G = E/(2*(1+nu))
        double Gf = (double) (Ef / (2 * (1 + Muf))); // [Pa]
        double Gm = (double) (Em / (2 * (1 + Mum))); // [Pa]

        //Bepalen El (longitudinale stijfheid) lamel, met mengselregel:
        double El = (double) (vf * Ef + vm * Em); // [Pa]

        //Bepalen Mlt (long. trans. poissons) voor lamel
        double Mult = (double) (Muf * vf + Mum * vm); // [-]

        //Bepalen Glt (long. trans. glijmod.) van lamel. daar is Nlt voor nodig.
        //Nlt:
        double Nlt = (double)(0.5 * (1 + (Gm / Gf))); // [-]
        double Glt = (double)(1 / ((vf / (vf + Nlt * vm)) * (1 / Gf) + ((Nlt * vm) / (vf + Nlt * vm)) * (1 / Gm))); // [Pa]
        
        // Bepalen compressiemodulus. 
        // k(f&m) = E/(3*(1-2nu)) (fibre en matrix)
        // Uit Nijhof, PATO cursus.
        // eerst voor fibre en matrix, dan voor lamel
        double kf = (double)(Ef/(3*(1-2*Muf))); // [Pa]
        double km = (double)(Em/(3*(1-2*Mum))); // [Pa]
        
        // Voor lamel eerst Nk bepalen:
        double Nk = (double)((1/(2*(1-Mum))) * (1+(Gm/kf))); // [-]
        
        // dan k, voor lamel:
        double k = (double) (1/((vf/(vf + Nk*vm))*(1/kf) + ((Nk*vm)/(vf+Nk*vm))*(1/km)));
        
        // Bepalen Gtt (Glijding trans. trans.)
        // Uit Nijhof, blz.94. (via vergelijk met Nijhof, PATO blijkt dat
        // Gtt.f en Glt.f van een vezel gelijk zijn.) Dit omdat vezel isotroop wordt
        // beschouwd.
        // eerst Ntt bepalen:
        double Ntt = (double)((1/(4*(1-Mum)))*(3-4*Mum+(Gm/Gf)));
        // Dan Gtt voor lamel
        double Gtt = (double)(1/((vf/(vf+Ntt*vm))*(1/Gf) + ((Ntt*vm)/(vf+Ntt*vm))*(1/Gm)));
        
        // bepalen Et (E mod, trans.) van lamel:
        // 2 mogelijkheden, Halpin, Tsaj en Hahn, of Halpin en Tsaj.
        // Halpin, Tsaj en Hahn:
        double EtHTH = (double)(1/((1/(4*Gtt)) + (1/(4*k)) + (Mult*Mult/El)));
        // Halpin en Tsaj: (Gebruikt in PATO cursus)
        //double EtHT = (double)(Em*((Ef+2*(vf*Ef+vm*Em))/(vm*Ef+vf*Em+2*Em)));
        
        // Keuze maken tussen de 2 verschllende schattingen:
        double Et=EtHTH;

        // vergelijk tussen (Halpin, Tsaj en Hahn) en (Halpin en Tsaj)
        // double vgl = EtHTH / EtHT ; // [-] // H&T is hoger dan HTH, misschien kiezen voor HTH 

        // Dichtheid
        double rhol=rhof*vf+rhom*vm; // dichtheid lamel

        // Bepalen Mutl
        // Mutl kan met Et, El en Mult berekend worden. (Nijhof blz. 47)
        // double Mutl = (Mult/El)*Et ; // [-]
        double Mutl = (double)((Mult/El)*Et);
        
        // Bij berekening van Glt en Et kan het voorkomen dat er 0/0 berekend wordt
        // als NaN. Ik dat geval zijn er waarschijnlijk allemaal nullen ingevuld als
        // materiaaleigenschappen. Et en Glt worden in dat geval ook op 0 gezet.
        
        double alphaL = (((afl*Ef*vf)+(am+Em+vm))/((Ef+vf)+(Em+vm)));
        double alphaT = ((1+Muf)*((afl+afr)/2)*vf)+((1+Mum)*am*vm-alphaL*Mult);
        return new Lamel(El,Et,Mult,Glt,rhol, alphaL, alphaT);
    }
    
    /**
     * Bereken stijfheidsmatrix van een lamel
     * @param lamel De {@code Lamel} waarvan de stijfheidsmatrix berekend moet worden
     * @return stijfheidsmatrix
     */
    public static Matrix qmat(Lamel lamel)
    {
        double El = lamel.getEl();
        double Mult = lamel.getMult();
        double Et = lamel.getEt();
        double Glt = lamel.getGlt();
        double Mutl = lamel.getMutl();
        
        double Q11 = (double) (El/(1-Mult*Mutl));
        double Q22 = (double) (Et/(1-Mult*Mutl));
        double Q12 = (double) ((Mutl*El)/(1-Mult*Mutl)); //Q12=Q21
        double Q66 = (double) Glt ;
         
        double[][] M = {{Q11,Q12,0},{Q12,Q22,0},{0,0,Q66}};
        
        return new Matrix(M);
    }
    
    /**
     * Bereken de Tinv onder een bepaalde hoek
     * @param hoek
     * @return Tinv
     */
    public static Matrix tmat(double hoek)
    {
        //omrekenen van graden naar radialen.
        double Th = (double)(((2*Math.PI)/360)*hoek);
        
        //cosinus en sinus berekenen
        double c = Math.cos(Th);
        double s = Math.sin(Th);
        
        //cos en sin in het kwadraat
        double c2 = c*c;
        double s2 = s*s;
        
        //matrix met berekende waardes
        double[][] M = new double[3][3];
        M[0][0] = c2;
        M[0][1] = s2;
        M[0][2] = (double)((-2)*c*s);
        M[1][0] = s2;
        M[1][1] = c2;
        M[1][2] = (double)(2*c*s);
        M[2][0] = (double) (c*s);
        M[2][1] = (double) ((-c)*s);
        M[2][2] = (double) (c2 - s2);
        return new Matrix(M);
    }
    
    /**
     * Bereken Qt matrix adhv de Tinv en Q1
     * @param Tinv
     * @param Q1
     * @return Qt
     */
    public static Matrix Qt(Matrix Tinv, Matrix Q1)
    {
        Matrix Qt = Tinv.times(Q1).times(Tinv.transpose());
        return Qt;
    }
    
    /**
     * Maak een matrix van de alpha waarden
     * @param alphaL
     * @param alphaT
     * @param alpha3
     * @return Qa
     */
    public static Matrix Qa(double alphaL, double alphaT, double alpha3)
    {
        Matrix m = new Matrix(1,3);
        m.set(0,0,alphaL);
        m.set(0,1,alphaT);
        m.set(0,2,alpha3);
        return m;
    }
    
    // Dit is oude code, iets aangepast om te werken met het nieuwe Laminaat, voor compatibiliteitsdoeleinden
    /**
     * Matrix met waarden om grafieken te maken
     * @param lam Een laminaat
     * @param data de database
     * @return Matrix met waarden om grafieken te maken
     */
    public static Matrix Mxtc(Laminaat lam) {
        int eindhoek = 360; // van 0 tot 360 graden
        int staphoek = 1; // in stappen van ... graden
        int aantstap = eindhoek / staphoek + 1; // aantal stappen
        Matrix out = new Matrix(aantstap, 6);
        int grad = 0; // eerste hoek is 0-graden
        for (int gind = 0; gind < aantstap; gind++) {
            double e1 = lam.getE1();
            double e2 = lam.getE2();
            double mu12 = lam.getMu12();
            double mu21 = lam.getMu21();
            double g12 = lam.getG12();
            out.set(gind, 0, grad);
            out.set(gind, 1, e1);
            out.set(gind, 2, e2);
            out.set(gind, 3, mu12);
            out.set(gind, 4, mu21);
            out.set(gind, 5, g12);
            grad += staphoek;
        }
        return out;
    }
}
